/*
 *  jQuery OwlCarousel v1.3.3
 *
 *  Copyright (c) 2013 Bartosz Wojciechowski
 *  http://www.owlgraphic.com/owlcarousel/
 *
 *  Licensed under MIT
 *
 */

/* JS Lint helpers: */
/* global jQuery, alert, window, document */
/* jslint nomen: true, continue:true */
/* eslint complexity: 0 */

if (typeof Object.create !== 'function') {
  Object.create = function (obj) {
    function F() {
    }

    F.prototype = obj;
    return new F();
  };
}
(function ($, window, document) {

  let Carousel = {
    init: function (options, el) {
      let base = this;

      base.$elem = $(el);
      base.options = $.extend({}, $.fn.owlCarousel.options, base.$elem.data(), options);

      base.userOptions = options;
      base.loadContent();
    },

    loadContent: function () {
      let base = this, url;

      function getData(data) {
        let i, content = '';

        if (typeof base.options.jsonSuccess === 'function') {
          base.options.jsonSuccess.apply(this, [data]);
        } else {
          for (i in data.owl) {
            if (data.owl.hasOwnProperty(i)) {
              content += data.owl[i].item;
            }
          }
          base.$elem.html(content);
        }
        base.logIn();
      }

      if (typeof base.options.beforeInit === 'function') {
        base.options.beforeInit.apply(this, [base.$elem]);
      }

      if (typeof base.options.jsonPath === 'string') {
        url = base.options.jsonPath;
        $.getJSON(url, getData);
      } else {
        base.logIn();
      }
    },

    logIn: function () {
      let base = this;

      base.$elem.data('owl-originalStyles', base.$elem.attr('style'));
      base.$elem.data('owl-originalClasses', base.$elem.attr('class'));

      base.$elem.css({opacity: 0});
      base.orignalItems = base.options.items;
      base.checkBrowser();
      base.wrapperWidth = 0;
      base.checkVisible = null;
      base.setVars();
    },

    setVars: function () {
      let base = this;

      if (base.$elem.children().length === 0) {
        return false;
      }
      base.baseClass();
      base.eventTypes();
      base.$userItems = base.$elem.children();
      base.itemsAmount = base.$userItems.length;
      base.wrapItems();
      base.$owlItems = base.$elem.find('.owl-item');
      base.$owlWrapper = base.$elem.find('.owl-wrapper');
      base.playDirection = 'next';
      base.prevItem = 0;
      base.prevArr = [0];
      base.currentItem = 0;
      base.customEvents();
      base.onStartup();
    },

    onStartup: function () {
      let base = this;

      base.updateItems();
      base.calculateAll();
      base.buildControls();
      base.updateControls();
      base.response();
      base.moveEvents();
      base.stopOnHover();
      base.owlStatus();

      if (base.options.transitionStyle !== false) {
        base.transitionTypes(base.options.transitionStyle);
      }
      if (base.options.autoPlay === true) {
        base.options.autoPlay = 5000;
      }
      base.play();

      base.$elem.find('.owl-wrapper').css('display', 'block');

      if (!base.$elem.is(':visible')) {
        base.watchVisibility();
      } else {
        base.$elem.css('opacity', 1);
      }
      base.onstartup = false;
      base.eachMoveUpdate();
      if (typeof base.options.afterInit === 'function') {
        base.options.afterInit.apply(this, [base.$elem]);
      }
    },

    eachMoveUpdate: function () {
      let base = this;

      if (base.options.lazyLoad === true) {
        base.lazyLoad();
      }
      if (base.options.autoHeight === true) {
        base.autoHeight();
      }
      base.onVisibleItems();

      if (typeof base.options.afterAction === 'function') {
        base.options.afterAction.apply(this, [base.$elem]);
      }
    },

    updateVars: function () {
      let base = this;

      if (typeof base.options.beforeUpdate === 'function') {
        base.options.beforeUpdate.apply(this, [base.$elem]);
      }
      base.watchVisibility();
      base.updateItems();
      base.calculateAll();
      base.updatePosition();
      base.updateControls();
      base.eachMoveUpdate();
      if (typeof base.options.afterUpdate === 'function') {
        base.options.afterUpdate.apply(this, [base.$elem]);
      }
    },

    reload: function () {
      let base = this;

      window.setTimeout(function () {
        base.updateVars();
      }, 0);
    },

    watchVisibility: function () {
      let base = this;

      if (base.$elem.is(':visible') === false) {
        base.$elem.css({opacity: 0});
        window.clearInterval(base.autoPlayInterval);
        window.clearInterval(base.checkVisible);
      } else {
        return false;
      }
      base.checkVisible = window.setInterval(function () {
        if (base.$elem.is(':visible')) {
          base.reload();
          base.$elem.animate({opacity: 1}, 200);
          window.clearInterval(base.checkVisible);
        }
      }, 500);
    },

    wrapItems: function () {
      let base = this;

      base.$userItems.wrapAll('<div class=\'owl-wrapper\'>').wrap('<div class=\'owl-item\'></div>');
      base.$elem.find('.owl-wrapper').wrap('<div class=\'owl-wrapper-outer\'>');
      base.wrapperOuter = base.$elem.find('.owl-wrapper-outer');
      base.$elem.css('display', 'block');
    },

    baseClass: function () {
      let base = this,
        hasBaseClass = base.$elem.hasClass(base.options.baseClass),
        hasThemeClass = base.$elem.hasClass(base.options.theme);

      if (!hasBaseClass) {
        base.$elem.addClass(base.options.baseClass);
      }

      if (!hasThemeClass) {
        base.$elem.addClass(base.options.theme);
      }
    },

    updateItems: function () {
      let base = this, width, i;

      if (base.options.responsive === false) {
        return false;
      }
      if (base.options.singleItem === true) {
        base.options.items = base.orignalItems = 1;
        base.options.itemsCustom = false;
        base.options.itemsDesktop = false;
        base.options.itemsDesktopSmall = false;
        base.options.itemsTablet = false;
        base.options.itemsTabletSmall = false;
        base.options.itemsMobile = false;
        return false;
      }

      width = $(base.options.responsiveBaseWidth).width();

      if (width > (base.options.itemsDesktop[0] || base.orignalItems)) {
        base.options.items = base.orignalItems;
      }
      if (base.options.itemsCustom !== false) {
        // reorder array by screen size
        base.options.itemsCustom.sort(function (a, b) {
          return a[0] - b[0];
        });

        for (i = 0; i < base.options.itemsCustom.length; i += 1) {
          if (base.options.itemsCustom[i][0] <= width) {
            base.options.items = base.options.itemsCustom[i][1];
          }
        }

      } else {

        if (width <= base.options.itemsDesktop[0] && base.options.itemsDesktop !== false) {
          base.options.items = base.options.itemsDesktop[1];
        }

        if (width <= base.options.itemsDesktopSmall[0] && base.options.itemsDesktopSmall !== false) {
          base.options.items = base.options.itemsDesktopSmall[1];
        }

        if (width <= base.options.itemsTablet[0] && base.options.itemsTablet !== false) {
          base.options.items = base.options.itemsTablet[1];
        }

        if (width <= base.options.itemsTabletSmall[0] && base.options.itemsTabletSmall !== false) {
          base.options.items = base.options.itemsTabletSmall[1];
        }

        if (width <= base.options.itemsMobile[0] && base.options.itemsMobile !== false) {
          base.options.items = base.options.itemsMobile[1];
        }
      }

      // if number of items is less than declared
      if (base.options.items > base.itemsAmount && base.options.itemsScaleUp === true) {
        base.options.items = base.itemsAmount;
      }
    },

    response: function () {
      let base = this,
        smallDelay,
        lastWindowWidth;

      if (base.options.responsive !== true) {
        return false;
      }
      lastWindowWidth = $(window).width();

      base.resizer = function () {
        if ($(window).width() !== lastWindowWidth) {
          if (base.options.autoPlay !== false) {
            window.clearInterval(base.autoPlayInterval);
          }
          window.clearTimeout(smallDelay);
          smallDelay = window.setTimeout(function () {
            lastWindowWidth = $(window).width();
            base.updateVars();
          }, base.options.responsiveRefreshRate);
        }
      };
      $(window).resize(base.resizer);
    },

    updatePosition: function () {
      let base = this;

      base.jumpTo(base.currentItem);
      if (base.options.autoPlay !== false) {
        base.checkAp();
      }
    },

    appendItemsSizes: function () {
      let base = this,
        roundPages = 0,
        lastItem = base.itemsAmount - base.options.items;

      base.$owlItems.each(function (index) {
        let $this = $(this);

        $this
          .css({width: base.itemWidth})
          .data('owl-item', Number(index));

        if (index % base.options.items === 0 || index === lastItem) {
          if (!(index > lastItem)) {
            roundPages += 1;
          }
        }
        $this.data('owl-roundPages', roundPages);
      });
    },

    appendWrapperSizes: function () {
      let base = this,
        width = base.$owlItems.length * base.itemWidth;

      base.$owlWrapper.css({
        width: width * 2,
        left: 0
      });
      base.appendItemsSizes();
    },

    calculateAll: function () {
      let base = this;

      base.calculateWidth();
      base.appendWrapperSizes();
      base.loops();
      base.max();
    },

    calculateWidth: function () {
      let base = this;

      base.itemWidth = Math.round(base.$elem.width() / base.options.items);
    },

    max: function () {
      let base = this,
        maximum = ((base.itemsAmount * base.itemWidth) - base.options.items * base.itemWidth) * -1;

      if (base.options.items > base.itemsAmount) {
        base.maximumItem = 0;
        maximum = 0;
        base.maximumPixels = 0;
      } else {
        base.maximumItem = base.itemsAmount - base.options.items;
        base.maximumPixels = maximum;
      }
      return maximum;
    },

    min: function () {
      return 0;
    },

    loops: function () {
      let base = this,
        prev = 0,
        elWidth = 0,
        i,
        item,
        roundPageNum;

      base.positionsInArray = [0];
      base.pagesInArray = [];

      for (i = 0; i < base.itemsAmount; i += 1) {
        elWidth += base.itemWidth;
        base.positionsInArray.push(-elWidth);

        if (base.options.scrollPerPage === true) {
          item = $(base.$owlItems[i]);
          roundPageNum = item.data('owl-roundPages');
          if (roundPageNum !== prev) {
            base.pagesInArray[prev] = base.positionsInArray[i];
            prev = roundPageNum;
          }
        }
      }
    },

    buildControls: function () {
      let base = this;

      if (base.options.navigation === true || base.options.pagination === true) {
        base.owlControls = $('<div class=\'owl-controls\'/>').toggleClass('clickable', !base.browser.isTouch).appendTo(base.$elem);
      }
      if (base.options.pagination === true) {
        base.buildPagination();
      }
      if (base.options.navigation === true) {
        base.buildButtons();
      }
    },

    buildButtons: function () {
      let base = this,
        buttonsWrapper = $('<div class=\'owl-buttons\'/>');

      base.owlControls.append(buttonsWrapper);

      base.buttonPrev = $('<div/>', {
        class: 'owl-prev',
        html: base.options.navigationText[0] || ''
      });

      base.buttonNext = $('<div/>', {
        class: 'owl-next',
        html: base.options.navigationText[1] || ''
      });

      buttonsWrapper
        .append(base.buttonPrev)
        .append(base.buttonNext);

      buttonsWrapper.on('touchstart.owlControls mousedown.owlControls', 'div[class^=\'owl\']', function (event) {
        event.preventDefault();
      });

      buttonsWrapper.on('touchend.owlControls mouseup.owlControls', 'div[class^=\'owl\']', function (event) {
        event.preventDefault();
        if ($(this).hasClass('owl-next')) {
          base.next();
        } else {
          base.prev();
        }
      });
    },

    buildPagination: function () {
      let base = this;

      base.paginationWrapper = $('<div class=\'owl-pagination\'/>');
      base.owlControls.append(base.paginationWrapper);

      base.paginationWrapper.on('touchend.owlControls mouseup.owlControls', '.owl-page', function (event) {
        event.preventDefault();
        if (Number($(this).data('owl-page')) !== base.currentItem) {
          base.goTo(Number($(this).data('owl-page')), true);
        }
      });
    },

    updatePagination: function () {
      let base = this,
        counter,
        lastPage,
        lastItem,
        i,
        paginationButton,
        paginationButtonInner;

      if (base.options.pagination === false) {
        return false;
      }

      base.paginationWrapper.html('');

      counter = 0;
      lastPage = base.itemsAmount - base.itemsAmount % base.options.items;

      for (i = 0; i < base.itemsAmount; i += 1) {
        if (i % base.options.items === 0) {
          counter += 1;
          if (lastPage === i) {
            lastItem = base.itemsAmount - base.options.items;
          }
          paginationButton = $('<div/>', {
            class: 'owl-page'
          });
          paginationButtonInner = $('<span></span>', {
            text: base.options.paginationNumbers === true ? counter : '',
            class: base.options.paginationNumbers === true ? 'owl-numbers' : ''
          });
          paginationButton.append(paginationButtonInner);

          paginationButton.data('owl-page', lastPage === i ? lastItem : i);
          paginationButton.data('owl-roundPages', counter);

          base.paginationWrapper.append(paginationButton);
        }
      }
      base.checkPagination();
    },
    checkPagination: function () {
      let base = this;

      if (base.options.pagination === false) {
        return false;
      }
      base.paginationWrapper.find('.owl-page').each(function () {
        if ($(this).data('owl-roundPages') === $(base.$owlItems[base.currentItem]).data('owl-roundPages')) {
          base.paginationWrapper
            .find('.owl-page')
            .removeClass('active');
          $(this).addClass('active');
        }
      });
    },

    checkNavigation: function () {
      let base = this;

      if (base.options.navigation === false) {
        return false;
      }
      if (base.options.rewindNav === false) {
        if (base.currentItem === 0 && base.maximumItem === 0) {
          base.buttonPrev.addClass('disabled');
          base.buttonNext.addClass('disabled');
        } else if (base.currentItem === 0 && base.maximumItem !== 0) {
          base.buttonPrev.addClass('disabled');
          base.buttonNext.removeClass('disabled');
        } else if (base.currentItem === base.maximumItem) {
          base.buttonPrev.removeClass('disabled');
          base.buttonNext.addClass('disabled');
        } else if (base.currentItem !== 0 && base.currentItem !== base.maximumItem) {
          base.buttonPrev.removeClass('disabled');
          base.buttonNext.removeClass('disabled');
        }
      }
    },

    updateControls: function () {
      let base = this;

      base.updatePagination();
      base.checkNavigation();
      if (base.owlControls) {
        if (base.options.items >= base.itemsAmount) {
          base.owlControls.hide();
        } else {
          base.owlControls.show();
        }
      }
    },

    destroyControls: function () {
      let base = this;

      if (base.owlControls) {
        base.owlControls.remove();
      }
    },

    next: function (speed) {
      let base = this;

      if (base.isTransition) {
        return false;
      }

      base.currentItem += base.options.scrollPerPage === true ? base.options.items : 1;
      if (base.currentItem > base.maximumItem + (base.options.scrollPerPage === true ? (base.options.items - 1) : 0)) {
        if (base.options.rewindNav === true) {
          base.currentItem = 0;
          speed = 'rewind';
        } else {
          base.currentItem = base.maximumItem;
          return false;
        }
      }
      base.goTo(base.currentItem, speed);
    },

    prev: function (speed) {
      let base = this;

      if (base.isTransition) {
        return false;
      }

      if (base.options.scrollPerPage === true && base.currentItem > 0 && base.currentItem < base.options.items) {
        base.currentItem = 0;
      } else {
        base.currentItem -= base.options.scrollPerPage === true ? base.options.items : 1;
      }
      if (base.currentItem < 0) {
        if (base.options.rewindNav === true) {
          base.currentItem = base.maximumItem;
          speed = 'rewind';
        } else {
          base.currentItem = 0;
          return false;
        }
      }
      base.goTo(base.currentItem, speed);
    },

    goTo: function (position, speed, drag) {
      let base = this,
        goToPixel;

      if (base.isTransition) {
        return false;
      }
      if (typeof base.options.beforeMove === 'function') {
        base.options.beforeMove.apply(this, [base.$elem]);
      }
      if (position >= base.maximumItem) {
        position = base.maximumItem;
      } else if (position <= 0) {
        position = 0;
      }

      base.currentItem = base.owl.currentItem = position;
      if (base.options.transitionStyle !== false && drag !== 'drag' && base.options.items === 1 && base.browser.support3d === true) {
        base.swapSpeed(0);
        if (base.browser.support3d === true) {
          base.transition3d(base.positionsInArray[position]);
        } else {
          base.css2slide(base.positionsInArray[position], 1);
        }
        base.afterGo();
        base.singleItemTransition();
        return false;
      }
      goToPixel = base.positionsInArray[position];

      if (base.browser.support3d === true) {
        base.isCss3Finish = false;

        if (speed === true) {
          base.swapSpeed('paginationSpeed');
          window.setTimeout(function () {
            base.isCss3Finish = true;
          }, base.options.paginationSpeed);

        } else if (speed === 'rewind') {
          base.swapSpeed(base.options.rewindSpeed);
          window.setTimeout(function () {
            base.isCss3Finish = true;
          }, base.options.rewindSpeed);

        } else {
          base.swapSpeed('slideSpeed');
          window.setTimeout(function () {
            base.isCss3Finish = true;
          }, base.options.slideSpeed);
        }
        base.transition3d(goToPixel);
      } else {
        if (speed === true) {
          base.css2slide(goToPixel, base.options.paginationSpeed);
        } else if (speed === 'rewind') {
          base.css2slide(goToPixel, base.options.rewindSpeed);
        } else {
          base.css2slide(goToPixel, base.options.slideSpeed);
        }
      }
      base.afterGo();
    },

    jumpTo: function (position) {
      let base = this;

      if (typeof base.options.beforeMove === 'function') {
        base.options.beforeMove.apply(this, [base.$elem]);
      }
      if (position >= base.maximumItem || position === -1) {
        position = base.maximumItem;
      } else if (position <= 0) {
        position = 0;
      }
      base.swapSpeed(0);
      if (base.browser.support3d === true) {
        base.transition3d(base.positionsInArray[position]);
      } else {
        base.css2slide(base.positionsInArray[position], 1);
      }
      base.currentItem = base.owl.currentItem = position;
      base.afterGo();
    },

    afterGo: function () {
      let base = this;

      base.prevArr.push(base.currentItem);
      base.prevItem = base.owl.prevItem = base.prevArr[base.prevArr.length - 2];
      base.prevArr.shift();

      if (base.prevItem !== base.currentItem) {
        base.checkPagination();
        base.checkNavigation();
        base.eachMoveUpdate();

        if (base.options.autoPlay !== false) {
          base.checkAp();
        }
      }
      if (typeof base.options.afterMove === 'function' && base.prevItem !== base.currentItem) {
        base.options.afterMove.apply(this, [base.$elem]);
      }
    },

    stop: function () {
      let base = this;

      base.apStatus = 'stop';
      window.clearInterval(base.autoPlayInterval);
    },

    checkAp: function () {
      let base = this;

      if (base.apStatus !== 'stop') {
        base.play();
      }
    },

    play: function () {
      let base = this;

      base.apStatus = 'play';
      if (base.options.autoPlay === false) {
        return false;
      }
      window.clearInterval(base.autoPlayInterval);
      base.autoPlayInterval = window.setInterval(function () {
        base.next(true);
      }, base.options.autoPlay);
    },

    swapSpeed: function (action) {
      let base = this;

      if (action === 'slideSpeed') {
        base.$owlWrapper.css(base.addCssSpeed(base.options.slideSpeed));
      } else if (action === 'paginationSpeed') {
        base.$owlWrapper.css(base.addCssSpeed(base.options.paginationSpeed));
      } else if (typeof action !== 'string') {
        base.$owlWrapper.css(base.addCssSpeed(action));
      }
    },

    addCssSpeed: function (speed) {
      return {
        '-webkit-transition': 'all ' + speed + 'ms ease',
        '-moz-transition': 'all ' + speed + 'ms ease',
        '-o-transition': 'all ' + speed + 'ms ease',
        transition: 'all ' + speed + 'ms ease'
      };
    },

    removeTransition: function () {
      return {
        '-webkit-transition': '',
        '-moz-transition': '',
        '-o-transition': '',
        transition: ''
      };
    },

    doTranslate: function (pixels) {
      return {
        '-webkit-transform': 'translate3d(' + pixels + 'px, 0px, 0px)',
        '-moz-transform': 'translate3d(' + pixels + 'px, 0px, 0px)',
        '-o-transform': 'translate3d(' + pixels + 'px, 0px, 0px)',
        '-ms-transform': 'translate3d(' + pixels + 'px, 0px, 0px)',
        transform: 'translate3d(' + pixels + 'px, 0px,0px)'
      };
    },

    transition3d: function (value) {
      let base = this;

      base.$owlWrapper.css(base.doTranslate(value));
    },

    css2move: function (value) {
      let base = this;

      base.$owlWrapper.css({left: value});
    },

    css2slide: function (value, speed) {
      let base = this;

      base.isCssFinish = false;
      base.$owlWrapper.stop(true, true).animate({
        left: value
      }, {
        duration: speed || base.options.slideSpeed,
        complete: function () {
          base.isCssFinish = true;
        }
      });
    },

    checkBrowser: function () {
      let base = this,
        translate3D = 'translate3d(0px, 0px, 0px)',
        tempElem = document.createElement('div'),
        regex,
        asSupport,
        support3d,
        isTouch;

      tempElem.style.cssText = '  -moz-transform:' + translate3D +
        '; -ms-transform:' + translate3D +
        '; -o-transform:' + translate3D +
        '; -webkit-transform:' + translate3D +
        '; transform:' + translate3D;
      regex = /translate3d\(0px, 0px, 0px\)/g;
      asSupport = tempElem.style.cssText.match(regex);
      support3d = (asSupport !== null && asSupport.length === 1);

      isTouch = 'ontouchstart' in window || window.navigator.msMaxTouchPoints;

      base.browser = {
        support3d: support3d,
        isTouch: isTouch
      };
    },

    moveEvents: function () {
      let base = this;

      if (base.options.mouseDrag !== false || base.options.touchDrag !== false) {
        base.gestures();
        base.disabledEvents();
      }
    },

    eventTypes: function () {
      let base = this,
        types = ['s', 'e', 'x'];

      base.ev_types = {};

      if (base.options.mouseDrag === true && base.options.touchDrag === true) {
        types = [
          'touchstart.owl mousedown.owl',
          'touchmove.owl mousemove.owl',
          'touchend.owl touchcancel.owl mouseup.owl'
        ];
      } else if (base.options.mouseDrag === false && base.options.touchDrag === true) {
        types = [
          'touchstart.owl',
          'touchmove.owl',
          'touchend.owl touchcancel.owl'
        ];
      } else if (base.options.mouseDrag === true && base.options.touchDrag === false) {
        types = [
          'mousedown.owl',
          'mousemove.owl',
          'mouseup.owl'
        ];
      }

      base.ev_types.start = types[0];
      base.ev_types.move = types[1];
      base.ev_types.end = types[2];
    },

    disabledEvents: function () {
      let base = this;

      base.$elem.on('dragstart.owl', function (event) {
        event.preventDefault();
      });
      base.$elem.on('mousedown.disableTextSelect', function (e) {
        return $(e.target).is('input, textarea, select, option');
      });
    },

    gestures: function () {
      /* jslint unparam: true */
      let base = this,
        locals = {
          offsetX: 0,
          offsetY: 0,
          baseElWidth: 0,
          relativePos: 0,
          position: null,
          minSwipe: null,
          maxSwipe: null,
          sliding: null,
          dargging: null,
          targetElement: null
        };

      base.isCssFinish = true;

      function getTouches(event) {
        if (event.touches !== undefined) {
          return {
            x: event.touches[0].pageX,
            y: event.touches[0].pageY
          };
        }

        if (event.touches === undefined) {
          if (event.pageX !== undefined) {
            return {
              x: event.pageX,
              y: event.pageY
            };
          }
          if (event.pageX === undefined) {
            return {
              x: event.clientX,
              y: event.clientY
            };
          }
        }
      }

      function swapEvents(type) {
        if (type === 'on') {
          $(document).on(base.ev_types.move, dragMove);
          $(document).on(base.ev_types.end, dragEnd);
        } else if (type === 'off') {
          $(document).off(base.ev_types.move);
          $(document).off(base.ev_types.end);
        }
      }

      function dragStart(event) {
        let ev = event.originalEvent || event || window.event,
          position;

        if (ev.which === 3) {
          return false;
        }
        if (base.itemsAmount <= base.options.items) {
          return;
        }
        if (base.isCssFinish === false && !base.options.dragBeforeAnimFinish) {
          return false;
        }
        if (base.isCss3Finish === false && !base.options.dragBeforeAnimFinish) {
          return false;
        }

        if (base.options.autoPlay !== false) {
          window.clearInterval(base.autoPlayInterval);
        }

        if (base.browser.isTouch !== true && !base.$owlWrapper.hasClass('grabbing')) {
          base.$owlWrapper.addClass('grabbing');
        }

        base.newPosX = 0;
        base.newRelativeX = 0;

        $(this).css(base.removeTransition());

        position = $(this).position();
        locals.relativePos = position.left;

        locals.offsetX = getTouches(ev).x - position.left;
        locals.offsetY = getTouches(ev).y - position.top;

        swapEvents('on');

        locals.sliding = false;
        locals.targetElement = ev.target || ev.srcElement;
      }

      function dragMove(event) {
        let ev = event.originalEvent || event || window.event,
          minSwipe = function () {
            return base.newRelativeX / 5;
          },
          maxSwipe = function () {
            return base.maximumPixels + base.newRelativeX / 5;
          };

        base.newPosX = getTouches(ev).x - locals.offsetX;
        base.newPosY = getTouches(ev).y - locals.offsetY;
        base.newRelativeX = base.newPosX - locals.relativePos;

        if (typeof base.options.startDragging === 'function' && locals.dragging !== true && base.newRelativeX !== 0) {
          locals.dragging = true;
          base.options.startDragging.apply(base, [base.$elem]);
        }

        if ((base.newRelativeX > 8 || base.newRelativeX < -8) && (base.browser.isTouch === true)) {
          if (ev.preventDefault !== undefined) {
            ev.preventDefault();
          } else {
            ev.returnValue = false;
          }
          locals.sliding = true;
        }

        if ((base.newPosY > 10 || base.newPosY < -10) && locals.sliding === false) {
          $(document).off('touchmove.owl');
        }

        base.newPosX = Math.max(Math.min(base.newPosX, minSwipe()), maxSwipe());
        if (base.browser.support3d === true) {
          base.transition3d(base.newPosX);
        } else {
          base.css2move(base.newPosX);
        }
      }

      function dragEnd(event) {
        let ev = event.originalEvent || event || window.event,
          newPosition,
          handlers,
          owlStopEvent,
          target = ev.target || ev.srcElement;

        locals.dragging = false;

        if (base.browser.isTouch !== true) {
          base.$owlWrapper.removeClass('grabbing');
        }

        if (base.newRelativeX < 0) {
          base.dragDirection = base.owl.dragDirection = 'left';
        } else {
          base.dragDirection = base.owl.dragDirection = 'right';
        }

        if (base.newRelativeX !== 0) {
          newPosition = base.getNewPosition();
          base.goTo(newPosition, false, 'drag');
          if (locals.targetElement === target && base.browser.isTouch !== true) {
            $(target).on('click.disable', function (ev) {
              ev.stopImmediatePropagation();
              ev.stopPropagation();
              ev.preventDefault();
              $(target).off('click.disable');
            });
            handlers = $._data(target, 'events').click;
            owlStopEvent = handlers.pop();
            handlers.splice(0, 0, owlStopEvent);
          }
        }
        swapEvents('off');
      }

      base.$elem.on(base.ev_types.start, '.owl-wrapper', dragStart);
    },

    getNewPosition: function () {
      let base = this,
        newPosition = base.closestItem();

      if (newPosition > base.maximumItem) {
        base.currentItem = base.maximumItem;
        newPosition = base.maximumItem;
      } else if (base.newPosX >= 0) {
        newPosition = 0;
        base.currentItem = 0;
      }
      return newPosition;
    },
    closestItem: function () {
      let base = this,
        array = base.options.scrollPerPage === true ? base.pagesInArray : base.positionsInArray,
        goal = base.newPosX,
        closest = null;

      $.each(array, function (i, v) {
        if (goal - (base.itemWidth / 20) > array[i + 1] && goal - (base.itemWidth / 20) < v && base.moveDirection() === 'left') {
          closest = v;
          if (base.options.scrollPerPage === true) {
            base.currentItem = $.inArray(closest, base.positionsInArray);
          } else {
            base.currentItem = i;
          }
        } else if (goal + (base.itemWidth / 20) < v && goal + (base.itemWidth / 20) > (array[i + 1] || array[i] - base.itemWidth) && base.moveDirection() === 'right') {
          if (base.options.scrollPerPage === true) {
            closest = array[i + 1] || array[array.length - 1];
            base.currentItem = $.inArray(closest, base.positionsInArray);
          } else {
            closest = array[i + 1];
            base.currentItem = i + 1;
          }
        }
      });
      return base.currentItem;
    },

    moveDirection: function () {
      let base = this,
        direction;

      if (base.newRelativeX < 0) {
        direction = 'right';
        base.playDirection = 'next';
      } else {
        direction = 'left';
        base.playDirection = 'prev';
      }
      return direction;
    },

    customEvents: function () {
      /* jslint unparam: true */
      let base = this;

      base.$elem.on('owl.next', function () {
        base.next();
      });
      base.$elem.on('owl.prev', function () {
        base.prev();
      });
      base.$elem.on('owl.play', function (event, speed) {
        base.options.autoPlay = speed;
        base.play();
        base.hoverStatus = 'play';
      });
      base.$elem.on('owl.stop', function () {
        base.stop();
        base.hoverStatus = 'stop';
      });
      base.$elem.on('owl.goTo', function (event, item) {
        base.goTo(item);
      });
      base.$elem.on('owl.jumpTo', function (event, item) {
        base.jumpTo(item);
      });
    },

    stopOnHover: function () {
      let base = this;

      if (base.options.stopOnHover === true && base.browser.isTouch !== true && base.options.autoPlay !== false) {
        base.$elem.on('mouseover', function () {
          base.stop();
        });
        base.$elem.on('mouseout', function () {
          if (base.hoverStatus !== 'stop') {
            base.play();
          }
        });
      }
    },

    lazyLoad: function () {
      let base = this,
        i,
        $item,
        itemNumber,
        $lazyImg,
        follow;

      if (base.options.lazyLoad === false) {
        return false;
      }
      for (i = 0; i < base.itemsAmount; i += 1) {
        $item = $(base.$owlItems[i]);

        if ($item.data('owl-loaded') === 'loaded') {
          continue;
        }

        itemNumber = $item.data('owl-item');
        $lazyImg = $item.find('.lazyOwl');

        if (typeof $lazyImg.data('src') !== 'string') {
          $item.data('owl-loaded', 'loaded');
          continue;
        }
        if ($item.data('owl-loaded') === undefined) {
          $lazyImg.hide();
          $item.addClass('loading').data('owl-loaded', 'checked');
        }
        if (base.options.lazyFollow === true) {
          follow = itemNumber >= base.currentItem;
        } else {
          follow = true;
        }
        if (follow && itemNumber < base.currentItem + base.options.items && $lazyImg.length) {
          base.lazyPreload($item, $lazyImg);
        }
      }
    },

    lazyPreload: function ($item, $lazyImg) {
      let base = this,
        iterations = 0,
        isBackgroundImg;

      if ($lazyImg.prop('tagName') === 'DIV') {
        $lazyImg.css('background-image', 'url(' + $lazyImg.data('src') + ')');
        isBackgroundImg = true;
      } else {
        $lazyImg[0].src = $lazyImg.data('src');
      }

      function showImage() {
        $item.data('owl-loaded', 'loaded').removeClass('loading');
        $lazyImg.removeAttr('data-src');
        if (base.options.lazyEffect === 'fade') {
          $lazyImg.fadeIn(400);
        } else {
          $lazyImg.show();
        }
        if (typeof base.options.afterLazyLoad === 'function') {
          base.options.afterLazyLoad.apply(this, [base.$elem]);
        }
      }

      function checkLazyImage() {
        iterations += 1;
        if (base.completeImg($lazyImg.get(0)) || isBackgroundImg === true) {
          showImage();
        } else if (iterations <= 100) {// if image loads in less than 10 seconds
          window.setTimeout(checkLazyImage, 100);
        } else {
          showImage();
        }
      }

      checkLazyImage();
    },

    autoHeight: function () {
      let base = this,
        $currentimg = $(base.$owlItems[base.currentItem]).find('img'),
        iterations;

      function addHeight() {
        let $currentItem = $(base.$owlItems[base.currentItem]).height();

        base.wrapperOuter.css('height', $currentItem + 'px');
        if (!base.wrapperOuter.hasClass('autoHeight')) {
          window.setTimeout(function () {
            base.wrapperOuter.addClass('autoHeight');
          }, 0);
        }
      }

      function checkImage() {
        iterations += 1;
        if (base.completeImg($currentimg.get(0))) {
          addHeight();
        } else if (iterations <= 100) { // if image loads in less than 10 seconds
          window.setTimeout(checkImage, 100);
        } else {
          base.wrapperOuter.css('height', ''); // else remove height attribute
        }
      }

      if ($currentimg.get(0) !== undefined) {
        iterations = 0;
        checkImage();
      } else {
        addHeight();
      }
    },

    completeImg: function (img) {
      let naturalWidthType;

      if (!img.complete) {
        return false;
      }
      naturalWidthType = typeof img.naturalWidth;

      return !(naturalWidthType !== 'undefined' && img.naturalWidth === 0);
    },

    onVisibleItems: function () {
      let base = this,
        i;

      if (base.options.addClassActive === true) {
        base.$owlItems.removeClass('active');
      }
      base.visibleItems = [];
      for (i = base.currentItem; i < base.currentItem + base.options.items; i += 1) {
        base.visibleItems.push(i);

        if (base.options.addClassActive === true) {
          $(base.$owlItems[i]).addClass('active');
        }
      }
      base.owl.visibleItems = base.visibleItems;
    },

    transitionTypes: function (className) {
      let base = this;

      // Currently available: 'fade', 'backSlide', 'goDown', 'fadeUp'
      base.outClass = 'owl-' + className + '-out';
      base.inClass = 'owl-' + className + '-in';
    },

    singleItemTransition: function () {
      let base = this,
        outClass = base.outClass,
        inClass = base.inClass,
        $currentItem = base.$owlItems.eq(base.currentItem),
        $prevItem = base.$owlItems.eq(base.prevItem),
        prevPos = Math.abs(base.positionsInArray[base.currentItem]) + base.positionsInArray[base.prevItem],
        origin = Math.abs(base.positionsInArray[base.currentItem]) + base.itemWidth / 2,
        animEnd = 'webkitAnimationEnd oAnimationEnd MSAnimationEnd animationend';

      base.isTransition = true;

      base.$owlWrapper
        .addClass('owl-origin')
        .css({
          '-webkit-transform-origin': origin + 'px',
          '-moz-perspective-origin': origin + 'px',
          'perspective-origin': origin + 'px'
        });
      function transStyles(prevPos) {
        return {
          position: 'relative',
          left: prevPos + 'px'
        };
      }

      $prevItem
        .css(transStyles(prevPos, 10))
        .addClass(outClass)
        .on(animEnd, function () {
          base.endPrev = true;
          $prevItem.off(animEnd);
          base.clearTransStyle($prevItem, outClass);
        });

      $currentItem
        .addClass(inClass)
        .on(animEnd, function () {
          base.endCurrent = true;
          $currentItem.off(animEnd);
          base.clearTransStyle($currentItem, inClass);
        });
    },

    clearTransStyle: function (item, classToRemove) {
      let base = this;

      item.css({
        position: '',
        left: ''
      }).removeClass(classToRemove);

      if (base.endPrev && base.endCurrent) {
        base.$owlWrapper.removeClass('owl-origin');
        base.endPrev = false;
        base.endCurrent = false;
        base.isTransition = false;
      }
    },

    owlStatus: function () {
      let base = this;

      base.owl = {
        userOptions: base.userOptions,
        baseElement: base.$elem,
        userItems: base.$userItems,
        owlItems: base.$owlItems,
        currentItem: base.currentItem,
        prevItem: base.prevItem,
        visibleItems: base.visibleItems,
        isTouch: base.browser.isTouch,
        browser: base.browser,
        dragDirection: base.dragDirection
      };
    },

    clearEvents: function () {
      let base = this;

      base.$elem.off('.owl owl mousedown.disableTextSelect');
      $(document).off('.owl owl');
      $(window).off('resize', base.resizer);
    },

    unWrap: function () {
      let base = this;

      if (base.$elem.children().length !== 0) {
        base.$owlWrapper.unwrap();
        base.$userItems.unwrap().unwrap();
        if (base.owlControls) {
          base.owlControls.remove();
        }
      }
      base.clearEvents();
      base.$elem
        .attr('style', base.$elem.data('owl-originalStyles') || '')
        .attr('class', base.$elem.data('owl-originalClasses'));
    },

    destroy: function () {
      let base = this;

      base.stop();
      window.clearInterval(base.checkVisible);
      base.unWrap();
      base.$elem.removeData();
    },

    reinit: function (newOptions) {
      let base = this,
        options = $.extend({}, base.userOptions, newOptions);

      base.unWrap();
      base.init(options, base.$elem);
    },

    addItem: function (htmlString, targetPosition) {
      let base = this,
        position;

      if (!htmlString) {
        return false;
      }

      if (base.$elem.children().length === 0) {
        base.$elem.append(htmlString);
        base.setVars();
        return false;
      }

      base.unWrap();

      if (targetPosition === undefined || targetPosition === -1) {
        position = -1;
      } else {
        position = targetPosition;
      }

      if (position >= base.$userItems.length || position === -1) {
        base.$userItems.eq(-1).after(htmlString);
      } else {
        base.$userItems.eq(position).before(htmlString);
      }

      base.setVars();
    },

    removeItem: function (targetPosition) {
      let base = this,
        position;

      if (base.$elem.children().length === 0) {
        return false;
      }

      if (targetPosition === undefined || targetPosition === -1) {
        position = -1;
      } else {
        position = targetPosition;
      }

      base.unWrap();
      base.$userItems.eq(position).remove();
      base.setVars();
    }

  };

  $.fn.owlCarousel = function (options) {
    return this.each(function () {
      if ($(this).data('owl-init') === true) {
        return false;
      }
      $(this).data('owl-init', true);
      let carousel = Object.create(Carousel);

      carousel.init(options, this);
      $.data(this, 'owlCarousel', carousel);
    });
  };

  $.fn.owlCarousel.options = {

    items: 5,
    itemsCustom: false,
    itemsDesktop: [1199, 4],
    itemsDesktopSmall: [979, 3],
    itemsTablet: [768, 2],
    itemsTabletSmall: false,
    itemsMobile: [479, 1],
    singleItem: false,
    itemsScaleUp: false,

    slideSpeed: 200,
    paginationSpeed: 800,
    rewindSpeed: 1000,

    autoPlay: false,
    stopOnHover: false,

    navigation: false,
    navigationText: ['prev', 'next'],
    rewindNav: true,
    scrollPerPage: false,

    pagination: true,
    paginationNumbers: false,

    responsive: true,
    responsiveRefreshRate: 200,
    responsiveBaseWidth: window,

    baseClass: 'owl-carousel',
    theme: 'owl-theme',

    lazyLoad: false,
    lazyFollow: true,
    lazyEffect: 'fade',

    autoHeight: false,

    jsonPath: false,
    jsonSuccess: false,

    dragBeforeAnimFinish: true,
    mouseDrag: true,
    touchDrag: true,

    addClassActive: false,
    transitionStyle: false,

    beforeUpdate: false,
    afterUpdate: false,
    beforeInit: false,
    afterInit: false,
    beforeMove: false,
    afterMove: false,
    afterAction: false,
    startDragging: false,
    afterLazyLoad: false
  };
}(jQuery, window, document));
